/***************************************************
***  INITIALISATION DES STRUCTURES ET CONSTANTES ***
****************************************************/


// **** STRUCTURES + CONSTANTES ****


// **** MATRICE *****
Ligne_1=new Array ("vide","tour1_B","cavalier1_B","fou1_B","dame0_B","roi0_B","fou2_B","cavalier2_B","tour2_B");
Ligne_2=new Array ("vide","pion1_B","pion2_B","pion3_B","pion4_B","pion5_B","pion6_B","pion7_B","pion8_B");
Ligne_8=new Array ("vide","tour1_N","cavalier1_N","fou1_N","dame0_N","roi0_N","fou2_N","cavalier2_N","tour2_N");
Ligne_7=new Array ("vide","pion1_N","pion2_N","pion3_N","pion4_N","pion5_N","pion6_N","pion7_N","pion8_N");
Ligne_3=new Array ("vide","vide","vide","vide","vide","vide","vide","vide","vide");
//attention ici on est obliges de dupliquer la ligne sinon il recopie la reference a l'objet ds la matrice et non le contenu
//toute modif est donc repercutee sur chaque ligne
Ligne_4=new Array ("vide","vide","vide","vide","vide","vide","vide","vide","vide");
Ligne_5=new Array ("vide","vide","vide","vide","vide","vide","vide","vide","vide");
Ligne_6=new Array ("vide","vide","vide","vide","vide","vide","vide","vide","vide");
//comme un tableau commence a zero, soit on translate a chaque fois entre case matirce et coodonnes soit on ajoute une ligne vide
matrice=new Array(LigneVide,Ligne_1,Ligne_2,Ligne_3,Ligne_4,Ligne_5,Ligne_6,Ligne_7,Ligne_8);
// **** FIN MATRICE ****



// *** Tableau de stockage des coups ******
table = new Array ();
// *** Fin du tableau de stockage des coups ***




// **** CASE ****
//(merci de rendre carre l'echiquier, moi j'y arriverai pas...) MERCI DONC DE LE FAIRE.... STP
hauteurCase=38;
largeurCase=40;
// **** FIN CASE ****


// **** ECHIQUIER ****
//8 si on commence a 0 et 7 si on commence a 1
NombreCasesTotal=8;
echiquierX=plateau._x;
echiquierY=plateau._y;
largeurechiquier=plateau._width;
hauteurechiquier=plateau._height;
// **** FIN ECHIQUIER ****

//on met 0.5 pour decaler par rapport aux cases, cette solution n'est pas la plus elegante mais fonctionne bien. 
nbrPiecesNoiresPrises=0.5;
nbrPiecesBlanchesPrises=0.5;

tauxReductionPiece=75;
roi0_N.echec=false;
roi0_B.echec=roi0_N.echec;
roi0_N.roque=true;
roi0_B.roque=roi0_N.roque;
roi0_N.aBouge=false;
roi0_B.aBouge=roi0_N.aBouge;
// ***** FIN STRUCTURE + CONSTANTES

/*******************************************************************************************
***  POSITIONNE TOUTES LES PIECES CORRECTEMENT SUR LES CASES ET INITIALISE LEURS DONNEES ***
*******************************************************************************************/
function recalageTotal(){for(i=0; i<this.matrice.length; i++) {for(j=0; j<this.matrice.length; j++) { //plutot renommer en un truc genre "init..."
	recadrer(matrice[i][j],i,j,i,j);
	this[matrice[i][j]].couleur=this[matrice[i][j]]._name.substr(this[matrice[i][j]]._name.length-1,1);
	this[matrice[i][j]].ligneDepart=i;
	this[matrice[i][j]].colonneDepart=j;
	this[matrice[i][j]].ligneArrivee=i;
	this[matrice[i][j]].colonneArrivee=j;
	this[matrice[i][j]].niveau="0";
}}}
// *****************************************************************************************

/*******************************************************************************************
****************************  Colorie les pieces noires  ***********************************
*******************************************************************************************/
function colori () {
	for (i=0; i<9; i++) {
		acolremp1 = new Color(this[Ligne_8[i]].remp);
		acolremp2 = new Color(this[Ligne_7[i]].remp);
		// acolremp1.setRGB(0x000001);
		acolremp1.setRGB(parseInt(Math.random(1)*16777215), 16);
		// acolremp2.setRGB(parseInt(Math.random (1)*16777215),16);
		acolremp2.setRGB(parseInt(Math.random(1)*16777215), 16);
		// acolremp2.setRGB(0x000001);
		acolcont1 = new Color(this[Ligne_8[i]].cont);
		acolcont2 = new Color(this[Ligne_7[i]].cont);
		acolcont1.setRGB(parseInt(Math.random(1)*16777215), 16);
		// .setRGB(0xffffff);
		// acolcont2.setRGB(0xffffff);
		acolcont2.setRGB(parseInt(Math.random(1)*16777215), 16);
	}
}
// *****************************************************************************************

/**************************fonctions execute  l'initialisation***************************/
Numcoup=0;

this.colori();
this.recalageTotal();

/*************************************************************************************************************************
****************************************************  FIN INITIALISATION *************************************************
*************************************************************************************************************************/






/*************************************************************************************************************************
****************************************************  classe Coup   ******************************************************
*************************************************************************************************************************/

/*Dfinition des attributs*/

function coup(piece,lDep,colDep,piecePrise,lArr,colArr,couleur,type){//,cheminJeu){
	this.piece=piece;
	this.ligneDepart=lDep;
	this.colonneDepart=colDep;
	this.piecePrise=piecePrise;
	this.ligneArrivee=lArr;
	this.colonneArrivee=colArr;
	this.couleur=couleur;
	this.type=type;
}


/************************* mthodes de la classe Coup  **************************************/

/********* Afficher ******************/
coup.prototype.afficher=function () {
	trace("$$$$$$ AFFICHAGE COUP $$$$$$");
	trace("couleur: "+this.couleur+" piece : "+this.piece+" p depart : "+this.ligneDepart+ " q depart: "+this.colonneDepart);
	trace(" piece prise: "+this.piecePrise+" L arrivee: "+this.ligneArrivee+" q arr: "+this.colonneArrivee);
	trace("$$$$$$ FIN AFFICHAGE COUP $$$$$$");
}

/********* Tester ******************/
coup.prototype.tester = function (axial, diagonal) {
	var validite=false;
	this.u=this.ligneArrivee-this.ligneDepart;
	this.v=this.colonneArrivee-this.colonneDepart;
  if (this.piecePrise.substr(this.piecePrise.length-1,1)==this.couleur){
	//le coup est impossible: on est pose sur une piece de sa couleur
	trace("COUP INVALIDE : meme couleur");
  }else{
	//on regarde si on bouge droit ou s'il s'agit d'un cavalier sinon il faudrait un XOR mais cela n'hexiste que pour les bits ds flash 5 => deux ifs imbriques
	//si on ne bouge pas droit
	if (((this.u*this.v)!=0) and (Math.abs(this.u)!=Math.abs(this.v))){
		//on est dans le cas ou la piece n'a pas ete deplacee ni en diagonale (comme un fou) ni en axial (comme une tour)
		//tester si on est ds le cas d'un cheval, sinon, le coup est impossible.
		//on regarde s'il s'agit d'un cavalier et si la distance est bonne.
		if ((this.piece.substr(0,this.piece.length-3)=="cavalier")and(Math.abs(this.u*this.v)==2)){
			trace("LE COUP EST BON C'EST UN CAVALIER");
			validite=true;
		}else{trace("COUP INVALIDE : mv pas droit");}
	}else{// ds ce cas on a bouge suivant une diagonale ou un axe
			this.i=this.u;
			this.j=this.v;
//on divise par la norme de maniere a n'avoir que 1, -1 ou 0
			if (this.i!=0){this.i=this.i/Math.abs(this.i);}
			if (this.j!=0){this.j=this.j/Math.abs(this.j);}
			//var p=this.ligneDepart+this.i,q=this.colonneDepart+this.j;
			//reste a tester i et j suivant le type de la piece
			if ((this.i*this.j*diagonal!=0)||(this.i*this.j==0 and axial==1)){
				// si i*j=0 => n'est pas en  diagonale
				// si i*j=-1 ou 1 alors piece en diagonale
				// pour etre en diagonale il faut et il suffit que I*j!=0 et diagonal!=0
				// pour etre en  axial, il faut que i*j=0 et que axial=1
				var p=0,q=P;
				var kMax=Math.max(Math.abs(this.u),Math.abs(this.v));
				for(k=1;k<kMax;k++){
					p=this.ligneDepart+k*this.i;
					q=this.colonneDepart+k*this.j;
					if (matrice[p][q]!="vide"){
						trace("COUP IMPOSSIBLE : ON PASSE AU DESSUS D'UNE PIECE");
						k=NombreCasesTotal;
					}
				}
					 // si k =kmax alors le coup est valide. (pour l'instant)?????
			if (k==kmax){validite=true;}
			}else{trace("COUP IMPOSSIBLE : la piece ne bouge pas comme elle a droit");
			}

	}

	// test pour un pion
	if (this.piece.substr(0,this.piece.length-3)=="pion"){validite=this.testerPion();}
	//test pour le roi
	if (this.piece.substr(0,this.piece.length-3)=="roi") {validite=this.testerRoi();}
  }
// si le coup est impossible, il faut l'annuler
	if (!validite){
		if(this.type==0){
			trace ("on annule "+this.piecePrise);
			matrice[this.lignearrivee][this.colonnearrivee]=this.piecePrise;
			matrice[this.ligneDepart][this.colonneDepart]=this.piece;
			recadrer(this.piece,this.ligneDepart,this.colonneDepart,this.ancienneligne,this.ancienneColonne);
		}// else{/* a faire */ this.annulerCoupSpecial();}
	}
	return validite;
}

/********* testerRoi******************/
coup.prototype.testerRoi = function () {
var RoiOk=false;
var rockposs=false;
var colonneSautee=this.colonneDepart+(this.v/2);
var colonneTour=Math.min(this.colonneArrivee+this.v,NombreCasesTotal);
var laTourRoqueuse=matrice[this.ligneDepart][colonneTour];

	if (Math.max(Math.abs(this.u),Math.abs(this.v))==1){
		RoiOk=true;
		trace("LE COUP EST BON, C'EST UN ROI, il bouge comme il faut");
	}else{//c'est peut etre un coup special (roque)
			//il tente peut etre un roque
			//verifier qu'il bouge bien de deux colonnnes dans la meme rangee et que la intermediaire est vide
		if (Math.abs(this.v)==2 and this.u==0 and 	matrice[this.ligneDepart][colonneSautee]=="vide"and matrice[this.ligneDepart][colonneTour-(this.v/2)]=="vide"){
			trace("tentative de roque");
			rockposs=true;
		}else{rockposs=false; trace ("ROQUE IMPOSSIBLE : Dplacement ROI impossible");}
			//verifier qu'il n'est pas echec
		if (this.echec!=true and rockposs){
			trace("roque  possible : roi pas en echec");
			rockposs=true;
		}else{rockposs=false;trace ("ROQUE IMPOSSIBLE : ROI MENACE");}
			//verifier qu'il n'a pas bouge , verifier que la tour du cote ou il va n'a pas bouge
		if (this.aBouge!=true and rockposs){//et tour a pas bouge (a ajouter)
			trace("roque  possible : roi n'a pas bouge");
			rockposs=true;
		}else{rockposs=false;trace ("ROQUE IMPOSSIBLE : ROI bouge");}
			//virer la tour concernee : ligne du roi et colonne min(arrive+u,NbrCasesTotal) =>(9,8)-> 8 ou (1,8)->1
		if (rockposs){
			matrice[this.ligneDepart][colonneTour]="vide";
			//bouger le roi d'une case
			matrice[this.ligneDepart][colonneSautee]=this.piece;
			matrice[this.ligneDepart][this.colonneDepart]="vide";
		}
		//verifier qu'il n'est pas en echec
		//pour cela il faut envoyer a prenable une piece qui contient les bonnes donnees  car ici piece n'a pas ses
		//valeurs actualisees et si on le fait on va perdre ses origines, etc.
		//on cree un clone que l'on modifie, apres il faudra faire un "delete"
		var tempoRoi=clone(DonneObjetPiece(this.piece));
		//on ajuste les proprietes du clone ;
		tempoRoi.colonnearrivee=colonneSautee;

		var original=DonneObjetPiece(this.piece);

		if (!prenable(tempoRoi) and rockposs){
			trace("roque possible : pas en echec");
			rockposs=true;
		}else{rockposs=false;trace ("ROQUE IMPOSSIBLE : ROI MENACE sur case intermediaire");}
		//bouger le roi a la case definitive
		//mettre la tour a la place precedente du  roi
		if (rockposs){trace("roque possible : pas en echec");
			matrice[this.ligneDepart][this.colonneArrivee]=matrice[this.ligneDepart][colonneSautee];
			matrice[this.ligneDepart][this.colonneArrivee]=this.piece;
			matrice[this.ligneDepart][ColonneSautee]=laTourRoqueuse;
		}else{trace ("ROQUE IMPOSSIBLE : ROI MENACE sur case intermediaire");}
	
			//verifier que le roi n'est pas echec
			//verifier qu'il n'est pas en echec
		if (!prenable(this.piece) and rockposs){
			trace("roque possible : pas en echec");
			rockposs=true;
			this.type=3;
		}else{rockposs=false;trace ("ROQUE IMPOSSIBLE : ROI MENACE sur case finale");}

		// on remet tout au depart
		matrice[this.ligneDepart][this.colonneDepart]=this.piece;
		matrice[this.ligneDepart][colonneSautee]="vide";
		matrice[this.ligneDepart][this.colonneArrivee]="vide";
		matrice[this.ligneDepart][colonneTour]=laTourRoqueuse;//ces variables ne sont pas tj definies

//on tue le clone, c'est une variable, expire seule normalement.
//delete tempoRoi;
		RoiOk=rockposs;
  	}	
return RoiOk;
}
/*********  fin methode testerRoi ******************/


/*********  methode testerPion ******************/
coup.prototype.testerPion = function () {
var pionok=false;
//placer les cas les plus courants en premier
// on a besoin a chaque  fois de + pour les blanc et - pour les noirs
if (this.couleur=="B"){signeSens=1;}else{signeSens=-1;}
		//test si le pion avance
//  if ( ( (this.u==1 and this.couleur=="B" )||(this.u==-1 and this.couleur=="N")) and this.v==0 and this.piecePrise=="vide") {//devient
		if ( this.u==signeSens*1 and this.v==0 and this.piecePrise=="vide") {
			pionok=true; trace("LE COUP EST BON C UN PION");
			//test de la mise a la dame
			if(this.lignearrivee==4.5+signeSens*3.5){this.type=2;}
		}else{
		//test si le pion prend une piece
// if ( ((this.u==1 and this.couleur=="B") ||(this.u==-1 and this.couleur=="N")) and Math.abs(this.v)==1 and this.piecePrise!="vide") { //devient
			if ( this.u==signeSens*1 and Math.abs(this.v)==1 and this.piecePrise!="vide") {
				pionok=true; trace("LE COUP EST OK C'EST UN PION qui prend une piece");
				//test de la mise a la dame
				if(this.lignearrivee==4.5+signeSens*3.5){this.type=2;}
			}else{
				//test si le pion avance de deux cases au debut
// if ( ((this.u==2 and this.couleur=="B" and this.ligneDepart==2 and matrice[this.ligneDepart+1][this.colonneDepart]=="vide") ||(this.u==-2 and this.couleur=="N" and this.ligneDepart==7 and matrice[this.ligneDepart-1][this.colonneDepart]=="vide")) and Math.abs(this.v)==0) {//devient
					if ( this.ligneDepart==4.5-signeSens*2.5 and this.u==signeSens*2 and matrice[this.ligneDepart+signeSens*1][this.colonneDepart]=="vide" and Math.abs(this.v)==0){
						pionok=true; trace("LE COUP EST BON C'EST UN PION qui avance de deux cases");

						// il faut qu'on le note comme etant prenable en passant
						//  il faut indiquer le ou les 2 PEP possibles
						// si B alors N en L4 et Delta col=1 mais attention il faut les deux
						var PEPDroit=DonneObjetPiece(matrice[this.lignearrivee][this.colonnedepart+1]);
						var PEPGauche=DonneObjetPiece(matrice[this.lignearrivee][this.colonnedepart-1]);
						affectePEP(this.piece,pepdroit,pepgauche);
					}else{
						//test si le pion fait une prise en passant
//if ( ((this.ligneDepart==5 and this.couleur=="B" and this.ligneArrivee==6) ||(this.LigneDepart==4 and this.couleur=="N" and this.ligneArrivee==3)) and Math.abs(this.v)==1 and this.piecePrise=="vide") { //devient
						if ( this.LigneDepart==4.5+signeSens*.5 and this.u==signeSens*1 and Math.abs(this.v)==1 and this.piecePrise=="vide") {

					// si la case de la ligne de depart  et de la colonne d'arrivee est occuppee par un pion de la couleur adverse.
					// alors il faut que ce pion se soit deplace de deux cases le coup d'avant 
							var PEPVictime=DonneObjetPiece(matrice[this.ligneDepart][this.colonneArrivee]);
							if (PEPVictime.couleur!=this.couleur and Math.abs(PEPVictime.ligneArrivee-PEPVictime.ligneDepart)==2 and (PEPVictime.pep1==this.piece or PEPVictime.pep2==this.piece)){
								pionok=true; 
								trace("LE COUP EST BON C UN PION qui prend en passant");
								this.pieceprise=PEPVictime._name;
								this.type=1;
							}else{pionok=false; trace("on a tente de faire une prise en passant, mais pas top");}
						}else{pionok=false;}
					}
			}
		}
return pionok;
}
/*********  fin methode testerPion ******************/

/************* methode effectuer*********************/
coup.prototype.effectuer = function () {
//on regarde si y'a une prise
	if (this.pieceprise!="vide"){
		sortirPiece(this.piecePrise);
		if (this.couleur=="B"){
			nbrPiecesNoiresPrises++;
		}else{
			nbrPiecesBlanchesPrises++;
		}
	}

	// bouger ds la matrice
	matrice[this.lignearrivee][this.colonnearrivee]=matrice[this.ligneDepart][this.colonneDepart];
	matrice[this.ligneDepart][this.colonneDepart]="vide";

//si c un coup special alors il faut faire les modifs pour

//traite le coup special de la prise en passant
	if (this.type==1){matrice[this.ligneDepart][this.ligneArrivee]="vide";}

	recadrer(this.piece,this.lignearrivee,this.colonnearrivee,this.ligneDepart,this.colonneDepart);	

// traite le coup special de promotion
	if (this.type==2){
		trace ("PROMOTION PROMOTION PROMOTION PROMOTION PROMOTION PROMOTION PROMOTION");
		var indice=this.piece.substr(this.piece.length-3,1);
		var chaine="jeu.dame"+indice+"_"+this.couleur;
		var tempoobj=_root.jeu["dame0_B"];
		var Lapromotion="dame"+this.piece.substr(this.piece.length-3,1)+"_"+this[this.piece].couleur;
		this.promu=Lapromotion;
		var typePromotion="dame";
		promotion(this.piece,typePromotion,this.piece.substr(this.piece.length-3,1)+"_"+this.couleur);
	}else{}

	if (this.type==3){
		var possTour=Math.min(this.colonneArrivee+this.v,NombreCasesTotal);
		var latour=matrice[this.ligneDepart][possTour];
		matrice[this.ligneDepart][this.colonneDepart+(this.v/2)]=laTour;
		matrice[this.ligneDepart][possTour]="vide";
		recadrer(latour,this.lignearrivee,this.colonneDepart+(this.v/2),this.ligneDepart,possTour);	

	}else{}
}

/************* fin methode effectuer*********************/



/************* methode annuler *********************/
coup.prototype.annuler = function () {
	// bouger ds la matrice
	matrice[this.lignearrivee][this.colonnearrivee]=this.piecePrise;
	matrice[this.ligneDepart][this.colonneDepart]=this.piece;

	//recadrer graphiquement
	recadrer(this.piece,this.ligneDepart,this.colonneDepart,this.ancienneLigne,this.ancienneColonne);

	//annule une prise
	if (this.pieceprise!="vide"){
		//this.afficher();
		redimentionner(this.piecePrise,10000/tauxReductionPiece);	
		matrice[this.lignearrivee][this.colonnearrivee]=this.piecePrise;
		recadrer(this.piecePrise,this.lignearrivee,this.colonnearrivee,this.ligneDepart,this.ColonneArrivee);	

		//sortirPiece(this.piecePrise);
		if (this.couleur=="B"){ nbrPiecesNoiresPrises--;}else{ nbrPiecesBlanchesPrises--;}
	}
	if(this.type==2){removeMovieClip(this.promu)}
}
/************* fin methode annuler *********************/


/************* methode Stocker *********************/
coup.prototype.stocker = function () {
	loadVariablesNum ("http://xplicite-04/ecrire.php?piece="+this.piece+"&rangeeDepart="+this.rangeeDepart+"&colonneDepart="+this.colonneDepart+"&piecePrise="+this.piecePrise+"&rangeeArrivee="+this.ligneArrivee+"&colonneArrivee="+this.colonneArrivee+"&couleur="+this.couleur+"&type="+this.type+"&u="+this.u+"&v="+this.v,0)
	result=_root["jeu2"].table.push(this);
	if (this.couleur=="B"){_parent.jeton="N";}else{_parent.jeton="B";}
return(result);
}
/************* fin methode Stocker *********************/ 


/************* methode ProtegeRoi *********************/
coup.prototype.ProtegeRoi = function () {
	var roisauf=true;
	var LeRoi="roi0_"+this.couleur;
	if (prenable(LeRoi) ) {trace("le roi est prenable");roisauf=false;}else{trace("le roi est sauf");}
	return roisauf;
}
/************* fin methode ProtegeRoi *********************/


/***************************************Fin des mthodes de la classe Coup ***********************************/









/*********************************
***  FONCTIONS ET PROCEDURES   ***
**********************************/

// affichages

function Affiche(piece){
trace(" AFFICHAGE d'UNE PIECE ");
	trace("piece: "+piece+" couleur: "+this[piece].couleur);
	trace("P/Q dep: "+this[piece].lignedepart+"/"+this[piece].colonneDepart+"matrice: "+matrice[this[piece].lignedepart][this[piece].colonneDepart]);
	trace("P/Q arr: "+this[piece].lignearrivee+"/"+this[piece].colonnearrivee+"matrice: "+matrice[this[piece].lignearrivee][this[piece].colonnearrivee]);
trace(" FIN AFFICHAGE d'UNE PIECE ");
}


function historique(){
trace(" AFFICHAGE de l'historique des coups ");
trace("1:"+table.length);
trace("2:"+this.table.length);
	for(i=0; i<table.length; i++) {
	table[i].Afficher();
	}
trace(" FIN AFFICHAGE de l'historique des coups ");
}

/********************************************************
***  AFFECTE LES NUM DE LIGNE ET COLONNE D'UNE PIECE  ***
********************************************************/
function affectePosition (piece, endroit) {
	//piece.ligne+endroit=donneLigne(piece);
//	piece.colonne+endroit=donneColonne(piece);
}
//* *****************************************************

/************************************************************
***  RETOURNE LA VALEUR DE LA LIGNE ACTUELLE D'UNE PIECE  ***
************************************************************/
function donneLigne(piece){return NombreCasesTotal-Math.floor((piece._y-echiquierY)/hauteurCase);}
//* *********************************************************


/**************************************************************
***  RETOURNE LA VALEUR DE LA COLONNE ACTUELLE D'UNE PIECE  ***
**************************************************************/
function donneColonne(piece){return 1+Math.floor((piece._x-echiquierX)/largeurCase);}
//* **********************************************************



/**********************************************
***  RECADRAGE D'UNE PIECE SUR L'ECHIQUIER  ***
***											***
*** p,q indiquent respectivement ligne et   ***
*** colonne de la case ou poser la piece    ***
**********************************************/
function recadrer(pieceStr,pa,qa,pd,qd){

//positionnement derriere
	this[pieceStr]._x=echiquierX+(qa-0.5)*largeurCase;
	this[pieceStr]._y=echiquierY+(NombreCasesTotal-(pa-0.5))*hauteurCase;

//positionnement sur le cote
//	this[pieceStr]._x=echiquierX+(NombreCasesTotal-(p-0.5))*largeurCase;
//  this[pieceStr]._y=echiquierY+(p-0.5)*hauteurCase;
	
	this[pieceStr].ligneArrivee=pa;
	this[pieceStr].colonneArrivee=qa;

	this[pieceStr].ligneDepart=pd;
	this[pieceStr].colonneDepart=qd;

}
// *******************************************



/**********************
***  REDIMENTIONNER ***
**********************/
function redimentionner(piece,taux){
	this[piece]._xscale=taux;
	this[piece]._yscale=taux;
}
// *****************************************************************************************


/**********************************************
***  		Traiter Deplacement	    ***
**********************************************/
function traiterDeplacement(piece){
	var pieceprise=matrice[piece.ligneArrivee][piece.colonneArrivee];
	//attention la on a un transtypage en principe interdit en objet.... encore une "lacune" de Flash enfin a voir.
	if (pieceprise!="vide"){pieceprise=this[pieceprise]._name;}
	var coupActuel=new coup(piece._name,piece.ligneDepart,piece.colonneDepart,piecePrise, piece.ligneArrivee,piece.colonneArrivee,piece.couleur,0);
	//,targetPath(this));
	coupActuel.afficher();
	if (coupActuel.tester(piece.axial,piece.diagonal)){//and coupActuel.ProtegeRoi()){
		coupActuel.effectuer();
		if(!coupActuel.ProtegeRoi()){
			coupActuel.annuler();
		}else{
			coupActuel.stocker();}
		AfficheMatrice();
	}else{coupActuel.TestCoupSpecial();
	}
}
// *******************************************


/**************************************************************************
*************************     Code bouton      ****************************
**************************************************************************/
on (press) {
	if (this.couleur==_parent.joueur and _parent._parent.jeton==this.couleur){
	// on positionne la pice saisie au premier plan (plan tres eleve)
	this.swapDepths(100);
	// on commence le "drag"
	startDrag (this);
//comme cela ou directement
	//_parent.affectePosition(this,"depart");
//directement, normalement on a pas besoin
//ancien depart
	this.ancienneLigne=this.ligneDepart;
	this.anciennecolonne=this.colonneDepart;
	this.ligneDepart=_parent.donneLigne(this);
	this.colonneDepart=_parent.donneColonne(this);
	
	}else{
		trace("PB FICHIER EXTERNE");
		trace(this._name);
		trace(this.couleur);
		trace(_parent.joueur);
		trace(_parent._parent.jeton);
	}
}
// *****************************************************************



/**************************************************************************
*** code valide pour toutes les pieces
*******************************************************************/
on (release) {
// on repositionne la pice a son plan d'origine
	this.swapDepths(this.niveau);
	// on arrete le "drag"
stopDrag ();
// on affecte les coordonnees d'arrivee
	this.ligneArrivee=_parent.donneLigne(this);
	this.colonneArrivee=_parent.donneColonne(this);
	// on traite le deplacement
_parent.traiterDeplacement(this);
}
/*************************Fin bouton*****************************/ 

/****************************************
***  GESTION DE LA PRISE D'UNE PIECE  ***
****************************************/


/**********************  la fonction prenable  ***********************/
function prenable(pieceATester){
trace("++++++++++++++++++++++++++++++++++++ type du truc a tester +++++++++++++++++++++++++");
trace(typeof(pieceATester));
trace("this. "+this.pieceATester.couleur);
trace("this[] "+this[pieceATester].couleur);
trace(". "+pieceATester.couleur);
trace("[] "+this[pieceATester][couleur]);
if (typeof(pieceATester)==typeof("chaine")){ObjetAtester=this[pieceATester]}else{ObjetAtester=pieceATester;}
trace("++++++++++++++++++++++++++++++++++++ fin du truc a tester +++++++++++++++++++++++++");
	var i=0,j=0,laPiece,typeLaPiece, resultat=false;
	var p=i, q=j, couleurLaPiece="";
	var prenable=false;
// calcul la distance entre pieceATester et les chevaux
//	trace("piece testee de couleur : "+this[pieceATester].couleur);

trace("%%%%% TEST CHEVAL %%%%%");
	if (ObjetAtester.couleur=="N"){
		if((distance2Pieces(ObjetAtester,this["cavalier1_B"])==5 )or (distance2Pieces(ObjetAtester,this["cavalier2_B"])==5)){prenable=true;}
	}else{
		if((distance2Pieces(ObjetAtester,this["cavalier1_N"])==5) or (distance2Pieces(ObjetAtester,this["cavalier2_N"])==5)){prenable=true;}
	}
	if (prenable){trace("PIECE "+pieceATester+ " MENACEE PAR UN CHEVAL")};

trace("%%%%% FIN TEST CHEVAL %%%%%");

//test le pion
trace("%%%%% TEST MENACE PION %%%%%");
if (ObjetAtester.couleur=="N"){
//this.piece.substr(0,this.piece.length-3)
		var pionDroit=matrice[ObjetAtester.lignearrivee-1][ObjetAtester.colonnearrivee+1];
		var pionGauche=matrice[ObjetAtester.lignearrivee-1][ObjetAtester.colonnearrivee-1];
trace ("couleur N "+ObjetAtester.couleur+"pion droit : "+pionDroit+" gauche: "+pionGauche);
		if ( (pionDroit.substr(0,pionDroit.length-3)=="pion" and(pionDroit.substr(pionDroit.length-1,1)=="B")) or  (pionGauche.substr(0,pionGauche.length-3)=="pion"and(pionGauche.substr(pionGauche.length-1,1)=="B")) ){trace("roi noir menace par pion blanc");prenable=true;}
	}else{
trace ("couleur B "+ObjetAtester.couleur+" pion droit : "+pionDroit+" gauche: "+pionGauche);
		var pionDroit=matrice[ObjetAtester.lignearrivee+1][ObjetAtester.colonnearrivee+1];
		var pionGauche=matrice[ObjetAtester.lignearrivee+1][ObjetAtester.colonnearrivee-1];
		if (( pionDroit.substr(0,pionDroit.length-3)=="pion" and(pionDroit.substr(pionDroit.length-1,1))=="N")or  (pionGauche.substr(0,pionGauche.length-3)=="pion"and(pionGauche.substr(pionGauche.length-1,1)=="N"))){trace("roi blanc menace par pion noir");prenable=true;}
	}
trace (pionDroit.substr(0,pionDroit.length-3)+" : "+pionDroit+" couleur: "+pionDroit.substr(pionDroit.length-1,1)+ " / "+pionGauche);
trace("%%%%% FIN TEST MENACE PION %%%%%");


/*
//test le roi
trace("%%%%% TEST ROI %%%%%");
if (ObjetAtester.couleur=="N"){
//this.piece.substr(0,this.piece.length-3)
		var pionDroit=matrice[ObjetAtester.lignearrivee-1][ObjetAtester.colonnearrivee+1];
		var pionGauche=matrice[ObjetAtester.lignearrivee-1][ObjetAtester.colonnearrivee-1];
trace ("couleur N "+ObjetAtester.couleur+"pion droit : "+pionDroit+" gauche: "+pionGauche);
		if ( (pionDroit.substr(0,pionDroit.length-3)=="pion" and(pionDroit.substr(pionDroit.length-1,1)=="B")) or  (pionGauche.substr(0,pionGauche.length-3)=="pion"and(pionGauche.substr(pionGauche.length-1,1)=="B")) ){trace("roi noir menace par pion blanc");prenable=true;}
	}else{
trace ("couleur B "+ObjetAtester.couleur+" pion droit : "+pionDroit+" gauche: "+pionGauche);
		var pionDroit=matrice[ObjetAtester.lignearrivee+1][ObjetAtester.colonnearrivee+1];
		var pionGauche=matrice[ObjetAtester.lignearrivee+1][ObjetAtester.colonnearrivee-1];
		if (( pionDroit.substr(0,pionDroit.length-3)=="pion" and(pionDroit.substr(pionDroit.length-1,1))=="N")or  (pionGauche.substr(0,pionGauche.length-3)=="pion"and(pionGauche.substr(pionGauche.length-1,1)=="N"))){trace("roi blanc menace par pion noir");prenable=true;}
	}
trace (pionDroit.substr(0,pionDroit.length-3)+" : "+pionDroit+" couleur: "+pionDroit.substr(pionDroit.length-1,1)+ " / "+pionGauche);
trace("%%%%% FIN TEST ROI %%%%%");

*/

//test si prenable par boucle

if (!prenable){	prenable=prenable or bouclePrise(ObjetAtester,0,1).capture or bouclePrise(ObjetAtester,1,0).capture or bouclePrise(ObjetAtester,1,1).capture or bouclePrise(ObjetAtester,0,-1).capture or bouclePrise(ObjetAtester,-1,0).capture or bouclePrise(ObjetAtester,-1,-1).capture or bouclePrise(ObjetAtester,-1,1).capture or bouclePrise(ObjetAtester,1,-1).capture;
}	var roi="roi0_"+ObjetAtester.couleur;
//attention la on est specifique au roi
	if( prenable) {
		trace("Attention piece "+pieceATester.substr(0,pieceATester.length-3)+" de couleur "+ObjetAtester.couleur+" menacee");
		this[roi].echec=true;
		this[roi].roque=false;
		AfficheMatrice();
	}else{
		this[roi].echec=false;
	}
		//pour le roque
		trace("roi N en echec ? "+this["roi0_N"].echec);
		trace("roi B en echec ? "+this["roi0_B"].echec);
		trace("roi N roque possible ? "+this["roi0_N"].roque);
		trace("roi B roque possible? "+this["roi0_B"].roque);
		trace("***************************************************");
	Affiche(pieceATester);


return prenable;
}
/**********************  Fin de la fonction prenable  ***********************/


// ******************* Calcul la distance entre deux pieces  *****************/
function distance2Pieces(piece,reference){
	var	magic=((piece.lignearrivee-reference.lignearrivee)*(piece.lignearrivee-reference.lignearrivee))+((piece.colonnearrivee-reference.colonnearrivee)*(piece.colonnearrivee-reference.colonnearrivee));
	return magic;
}

/************************ creation d'un objet capture  ***********************/
function capture(resultat,piece,LaPiece){
	this.capture=resultat;
	this.Prenante=piece;
	this.Prise=LaPiece;
}

/************ function boucle prise************************/
function bouclePrise(piece,u,v){
var resultat=false;
// u et v valent respectivement 0,1 1,0 1,1 0,-1 -1,0 -1,-1 -1,1 1,-1
	for (k=1;k<=NombreCasesTotal;k++){
			i=u*k;
			j=v*k;  
			 p=piece.lignearrivee+i;
			 q=piece.colonnearrivee+j;
			 LaPiece=matrice[p][q];
			 typeLaPiece=LaPiece.substr(0,LaPiece.length-3);
			 couleurLaPiece=LaPiece.substr(LaPiece.length-1,1);// alternative : this[Lapiece].couleur

//un cavalier ou un pion peuvent proteger la piece
		if((couleurLaPiece==piece.couleur)or(typeLaPiece=="pion")or(typeLaPiece=="cavalier")){k=NombreCasesTotal+1;
		}else{
		  if (TypeLaPiece=="roi"and k==1){  trace("roi menacant"); resultat=true;         }else{

			if (typeLaPiece=="dame"){trace("dame menacante"); resultat=true;
//si pas diagonale et si tour alors ok
			}else{	if(u*v==0 ){if (typeLaPiece=="tour"){trace("tour menacante");resultat=true;}
//si diagonale et si fou alors ok
					}else{if (typeLaPiece=="fou"){trace("fou menacant"); resultat=true;}
					}
			}//si la piece est de la meme couleur alors on incremente
		  }
		}
	}
	var shoot=new capture(resultat,piece,LaPiece);
	return shoot;
}
/************ fin boucle Prise  ****************/


/*******************************************
********  CREE LE CLONE D'UN OBJET ********
*******************************************/
function Clone (original){
	for (propriete in original) { 
	copie[propriete]=original[propriete];
	}return copie
}
/******************************************/



/************************ function sortirPiece  ***********************/
function sortirPiece(piecePrise){

//  redimentionnement d'une piece prise
//	this[piecePrise]._xscale=tauxReductionPiece;
//	this[piecePrise]._yscale=tauxReductionPiece;
	redimentionner(piecePrise,tauxReductionPiece);
	if (this[piecePrise].couleur=="N"){

		//sortir piece derriere
		//this[piecePrise]._x=echiquierX-1.5*largeurCase;
		//this[piecePrise]._y=echiquierY+(hauteurCase/2)*nbrPiecesNoiresPrises;

		//sortir piece sur le cote
		this[piecePrise]._x=echiquierX+(largeurCase/2)*nbrPiecesnoiresPrises;
		this[piecePrise]._y=echiquierY+largeurechiquier+hauteurCase;

		}
	else{
		//sortir piece derriere
		//this[piecePrise]._x=echiquierX+largeurechiquier+largeurCase;
		//this[piecePrise]._y=echiquierY+(hauteurCase/2)*nbrPiecesBlanchesPrises;

		//sortir piece sur le cote
		this[piecePrise]._x=echiquierX+(largeurCase/2)*nbrPiecesBlanchesPrises;
		this[piecePrise]._y=echiquierY-1.5*hauteurCase;
		
	}
}
/************************ Fin function sortirPiece  ***********************/



/****************************************
***  GESTION DE LA PRISE D'UNE PIECE  ***
****************************************/



/*******************************************
***  CONVERSTISSEUR NOM MATRICE -> OBJET ***
*******************************************/
function DonneObjetPiece(nom){return this[nom];}
// *****************************************


/****************************************
*************  Gestion du Pion *********
****************************************/

/*******************************************************************************************
******** MEMORISE LES PIONS QUI PEUVENT PRENDRE EN PASSANT LE PION CONSIDERE *************** 
*******************************************************************************************/
function affectePep(piece,pepD,pepG){

// afffectation pour les deux jeux, a voir qd ce sera en reseau
_root.jeu[piece].pep1=pepd._name;
_root.jeu[piece].pep2=pepg._name;

_root.jeu2[piece].pep1=pepd._name;
_root.jeu2[piece].pep2=pepg._name;
}
// *******************************************************************************************


/*************************************************************
***************  TRAITE LA PROMOTION d'UN PION *************** 
*************************************************************/
function promotion(lePion,typepiece,indice){
var piece=typepiece+indice;
	duplicateMovieClip("dame0_B",piece, 500);
	this[piece].couleur=this[lePion].couleur;
	this[piece].lignedepart=this[lePion].lignearrivee;
	this[piece].lignearrivee=this[lePion].lignearrivee;
	this[piece].colonneDepart=this[lePion].colonnearrivee;
	this[piece].colonnearrivee=this[lePion].colonnearrivee;
	this[piece]._width=this[lePion]._width;
	this[piece]._height=this[lePion]._height;
	this[piece].niveau=lePion.substr(lePion.length-3,1);
	this.matrice[this[lePion].lignearrivee][this[lePion].colonnearrivee]=piece;
	recadrer(piece,this[piece].lignearrivee,this[piece].colonnearrivee,this[piece].lignearrivee,this[piece].colonnearrivee);
	recadrer(lePion,0,0,0,0);
}
// *************************************************************























